package com.altran.web.service;


import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import javax.persistence.EntityExistsException;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityNotFoundException;
import javax.persistence.EntityTransaction;
import javax.persistence.NoResultException;
import javax.persistence.NonUniqueResultException;
import javax.persistence.Persistence;
import javax.persistence.PersistenceException;

import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;

import com.altran.web.model.Concepto;
import com.altran.web.model.Consultor;
import com.altran.web.model.Dedicacion;
import com.altran.web.utilities.Utilities;

public class GestionDedicacionesServImpl implements GestionDedicacionesServ {
	
	public static EntityManagerFactory factory =
			Persistence.createEntityManagerFactory("data");

	// --------------- Consultor ----------------
        /**
         * 
         * @param nombre
         * @param telefono
         * @param email
         * @throws PersistenceException 
         */
	@Override
	public void crearConsultor(String nombre, String telefono, String email) {
		
		EntityManager em = null; 
				
		try {
			em = factory.createEntityManager();
			EntityTransaction tx = em.getTransaction();
			tx.begin();
			Consultor consultor = new Consultor(nombre, telefono, email); 
			em.persist(consultor);
			tx.commit();	

		} catch (PersistenceException exc) {
			throw new PersistenceException("No se ha podido crear el consultor " + nombre + ".", exc);
		}
		finally {
			if(em!=null) {
				em.close();
			}
		}

	}
        
        /**
         * 
         * @param id_consultor
         * @param nombre
         * @param telefono
         * @param email
         * @throws PersistenceException 
         */
	@Override
	public void modificarConsultor(int id_consultor, String nombre, String telefono, String email) 
			throws PersistenceException {

		EntityManager em = null;
		try {
			em = factory.createEntityManager();
			EntityTransaction tx = em.getTransaction();
			tx.begin();
			
			// Como pasamos todos los parámetros, nos ahorramos una consulta a BD:
			Consultor consultor = em.getReference(Consultor.class, id_consultor);
			consultor.setNombre(nombre);
			consultor.setEmail(email);
			consultor.setTelf(telefono);
			tx.commit();
			
		} catch (EntityNotFoundException exc) {
			throw new PersistenceException("No se ha encontrado al consultor especificado. \n" + exc.getMessage());
		} finally {
			if (em != null) {
				em.close();
			}
		}
	}
	
        /**
         * 
         * 
         * @param nombre
         * @return 
         */
	@Override
	public Consultor buscarConsultorByNombre(String nombre) {
		EntityManager em = null;
		Consultor consultor = null;
		
		try {
			em = factory.createEntityManager();

			consultor = (Consultor) em.createNamedQuery("buscarConsultorByNombre")
					   .setParameter("nombre", nombre)
					   .getSingleResult();
			
		} 
		catch (NoResultException exc) {
			/* Si no encuentra el consultor a modificar, controlamos la excepción y enviamos referencia nula*/
			return null;
		} 
		catch (NonUniqueResultException exc) {
			/* Si encuentra múltiples resultados por ese mismo nombre avisamos mediante PersistenceException*/
			throw new PersistenceException("Varios consultores tienen ese mismo nombre.");
		} 
		finally {
			if (em != null) {
				em.close();
			}
		}
		return consultor;
	}
	
        /**
         * 
         * @param id
         * @return el consultor entero
         */
	@Override
	public Consultor buscarConsultorById(int id) {
		EntityManager em = null;
		Consultor consultor = null;
		
		try {
			em = factory.createEntityManager();
			consultor = (Consultor) em.createNamedQuery("buscarConsultorById")
					   .setParameter("id_consultor", id)
					   .getSingleResult();
		} 
		catch (NoResultException exc) {
			/* Si no encuentra el consultor a modificar, controlamos la excepción y retornamos referencia nula*/
			return null;
		} 
		catch (NonUniqueResultException exc) {
			/* Si encuentra múltiples resultados por ese mismo nombre avisamos mediante PersistenceException*/
			throw new PersistenceException("Varios consultores tienen ese identificador en la base de datos.");
		} 
		finally {
			if (em != null) {
				em.close();
			}
		}
		
		return consultor;
	}
	
        /**
         * 
         * @return lista completa de consultores
         */
	@SuppressWarnings("unchecked")
	@Override
	public List<Consultor> obtenerConsultores() {
		
		EntityManager em = null;
		List<Consultor> consultores = null;
		
		try {
			em = factory.createEntityManager();
			consultores = em.createNamedQuery("obtenerConsultores")
					      .getResultList();
		}
		catch (PersistenceException exc) {
			throw new PersistenceException("La conexión a base de datos a fallado. Intentelo de nuevo.");
		} 
		finally {
			if (em != null) {
				em.close();
			}
		}
		
		return consultores;
	}


	
	// --------------- Concepto ----------------
	/**
         * 
         * @param nombre
         * @throws PersistenceException 
         */
	@Override
	public void crearConcepto(String nombre) 
			throws PersistenceException {
		EntityManager em = null; 
		
		try {
			em = factory.createEntityManager();
			EntityTransaction tx = em.getTransaction();
			tx.begin();
			Concepto concepto = new Concepto(nombre);
			em.persist(concepto);
			tx.commit();
			
		} catch (PersistenceException exc) {
			throw new PersistenceException("No se ha podido crear el concepto " + nombre + ".", exc);
		}
		
		finally {
			if(em!=null) {
				em.close();
			}
		}

		
	}
        /**
         *
         * @param id_concepto
         * @param nombre
         * @throws PersistenceException
         */
	@Override
	public void modificarConcepto(int id_concepto, String nombre) 
			throws PersistenceException {
		EntityManager em = null;
		try {
			em = factory.createEntityManager();
			EntityTransaction tx = em.getTransaction();
			tx.begin();
			
			Concepto concepto = em.getReference(Concepto.class, id_concepto);
			concepto.setNombre(nombre);
			tx.commit();
			
		} catch (EntityNotFoundException exc) {
			throw new PersistenceException("No se ha encontrado el concepto. ");
		} finally {
			if (em != null) {
				em.close();
			}
		}
	}
	/** TODO refactorizar los métodos de forma que reciban fechaFin en lugar de numDias.
         * 
         * @param id_consultor
         * @param fechaInicio
         * @param numDias
         * @return 
         */
	@SuppressWarnings("unchecked")
    @Override
	public List<Concepto> obtenerConceptoByConsultorByPeriod(int id_consultor, Date fechaInicio, int numDias) {
		
		EntityManager em = null;
		List<Concepto> conceptos = null;
		Consultor consultor = null;
		
		if (fechaInicio == null) {
			fechaInicio = new Date();
		}
		fechaInicio = Utilities.FechaACero(fechaInicio);
		Date fechaFin;
		if (numDias == 0) {
			fechaFin = Utilities.calcularSumaMeses(fechaInicio, 1);
		} else { // +1 para que sea inclusivo
			fechaFin = Utilities.calcularSumaDias(fechaInicio, numDias+1);
		}
		
		try {
			em = factory.createEntityManager();
			consultor = em.getReference(Consultor.class, id_consultor);
			org.hibernate.Session session = 
					(org.hibernate.Session) em.getDelegate();
			//Ya haya empezado:
			Criterion fechaInicioRestriction = Restrictions.le("fechaInicio", fechaFin); 
			//No haya finalizado:
			Criterion fechaFinRestriction = Restrictions.or(Restrictions.ge("fechaFin", fechaInicio), Restrictions.isNull("fechaFin"));
			conceptos = session.createCriteria(Dedicacion.class)
					.add(Restrictions.eq("consultor", consultor))
					.setProjection(Projections.distinct(Projections.property("concepto")))
					.add(fechaInicioRestriction)
					.add(fechaFinRestriction)
					//.add(Restrictions.or(Restrictions.ge("fechaFin", fechaInicioNuevaDedicacion), Restrictions.isNull("fechaFin"))) 
					.list(); 
		} finally {
			if (em != null) {
				em.close();
			}
		}
		
		return conceptos;
	}
	
	/**
	 * @return List<Concepto> en la que están todos los conceptos disponibles de la capa de datos
	 */
	public List<Concepto> obtenerTodosConceptos() {
		
		EntityManager em = null;
		List<Concepto> conceptos = null;
		
		
		try {
			em = factory.createEntityManager();			
			conceptos = em.createNamedQuery("obtenerConceptos").getResultList();			

		} catch (PersistenceException exc) {
			throw new PersistenceException("La conexión a base de datos a fallado. Intentelo de nuevo.");
		} finally {
			if (em != null) {
				em.close();
			}
		}
		
		return conceptos;
	}
	
	// --------------- Dedicación ----------------
	
	/**
	 * Crea nueva dedicación.
	 * Comprueba que o se dé solapamiento para mismo consultor y concepto y que no se supere el 125% de dedicación ningún día.
	 * 
         * @param id_consultor
         * @param id_concepto
         * @param fechaInicioNuevaDedicacion
         * @param porcentajeDedicacionDiaria
         * @throws PersistenceException 
         */
    @SuppressWarnings("unchecked")
	public void crearDedicacion(int id_consultor, int id_concepto,
			Date fechaInicioNuevaDedicacion, Date fechaFinalNuevaDedicacion, int porcentajeDedicacionDiaria) 
					throws PersistenceException {
    	
		EntityManager em = null;
		EntityTransaction tx = null;
		Consultor consultor = null;
		Concepto concepto = null;
		System.out.println("INFO Creando Dedicación\n");
		
		try {
			em = factory.createEntityManager();
			tx = em.getTransaction();
			tx.begin();
			consultor = em.getReference(Consultor.class, id_consultor);
			concepto = em.getReference(Concepto.class, id_concepto);

			org.hibernate.Session session = 
					(org.hibernate.Session) em.getDelegate();

			// --- Evitar solapamiento para mismo concepto.
			// Select COUNT(d) dedicaciones para consultar si ya existe dedicación para ese concepto con fechaFinal >= fechaInicioNuevaDedicacion o no especificada.
					long count = (Long) session.createCriteria(Dedicacion.class)
						.add(Restrictions.eq("consultor", consultor))
						.add(Restrictions.eq("concepto", concepto))
						.add(Restrictions.or(Restrictions.ge("fechaFin", fechaInicioNuevaDedicacion), Restrictions.isNull("fechaFin"))) 
						.setProjection(Projections.rowCount())
						.list().get(0); 
			// Si hay solapamiento lanzamos error.			
			if (count > 0 ) {
				throw new PersistenceException("No pudo crearse la dedicación por solaparse con una existente para el mismo concepto.");
			}
			
			// --- Prohibir superar el 125% de dedicación para todo día.
			// 1. obtener  dedicaciones de todo concepto con fechaFinal > fechaInicioNuevaDedicacion o no especificada.
			List<Dedicacion> dedicaciones = 
					session.createCriteria(Dedicacion.class)
					.add(Restrictions.eq("consultor", consultor))
					.add(Restrictions.or(Restrictions.ge("fechaFin", fechaInicioNuevaDedicacion), Restrictions.isNull("fechaFin"))) 
					.list();
			// 2. Guardar en set ordenado (sin duplicados) todas las fechas fechaInicio y fechaFin de las dedicaciones en ese intervalo
			Set<Date> fechasInicioFin = new TreeSet<Date>();
			fechasInicioFin.add(fechaInicioNuevaDedicacion);
			for (Dedicacion dedicacion : dedicaciones) { 
				//TODO Añadir si son iguales las fechas.
				if (dedicacion.getFechaInicio().after(fechaInicioNuevaDedicacion)) {
					fechasInicioFin.add(dedicacion.getFechaInicio());
				}
				if (dedicacion.getFechaFin() != null && dedicacion.getFechaFin().after(fechaInicioNuevaDedicacion)) {
					fechasInicioFin.add(dedicacion.getFechaFin());
				}
			}
			// 3. para cada uno de los períodos resultantes entre esas fechas, hacer la suma de las dedicaciones de su primer día (el guardado).
			List<Dedicacion> dedicacionesPeriodo;
			for (Date date : fechasInicioFin) {
				dedicacionesPeriodo = obtenerDedicacionesByConsultorByPeriod(id_consultor, date, 0);
				
				int sumaPorcentajesPeriodo = 0;
				for (Dedicacion dedicacion : dedicacionesPeriodo) {
					sumaPorcentajesPeriodo += dedicacion.getPorcentajeDedicacionDiaria();
				}
				// 4. Lanzar excepción si la suma de alguno de esos períodos al porcentaje que se desea introducir resulta mayor de 125(%).
				if (sumaPorcentajesPeriodo + porcentajeDedicacionDiaria > 125) {
					throw new PersistenceException("No pudo crearse la dedicación porque se superaría el 125% de dedicación diaria el día.");
				}
				
			}
			// Si hemos llegado aquí es que todo está OK. Creamos una nueva Dedicacion CON o SIN fechaFinalNuevaDedicacion
			Dedicacion dedicacion = null;
			if (fechaFinalNuevaDedicacion != null)
				dedicacion = new Dedicacion(consultor, concepto, porcentajeDedicacionDiaria, fechaInicioNuevaDedicacion, fechaFinalNuevaDedicacion);
			else
				dedicacion = new Dedicacion(consultor, concepto, porcentajeDedicacionDiaria, fechaInicioNuevaDedicacion);
			em.persist(dedicacion);
			tx.commit();
			
		} catch (EntityExistsException exc) {
			throw new PersistenceException("No pudo crearse la dedicación porque ésta ya existe.", exc);
		}	
		finally {
			if(em!=null) {
				em.close();
			}
		}
	}




	/**
	 * Permite especificar la nueva fecha inicial a partir de la cúal la dedicación tendrá 
	 * el nuevo porcentaje especificado.
	 * 
	 * @param id_dedicacion
	 * @param fechaInicial
	 * @param porcentajeDedicacion
	 */
    @Override
	public void modificarDedicacion(int id_dedicacion, Date fechaInicial,
			int nuevoPorcentajeDedicacion) {
    	
		/*  1. Informar fecha final de la dedicación a modificar con la fecha
		 * del día anterior a la nueva fechaInicial.
		 */
		finalizarDedicacion(id_dedicacion, Utilities.calcularSumaDias(fechaInicial, -1));

		/*
		 * 2. Crear una nueva dedicación para mismo consultor y concepto con
		 * fecha inicial igual a la nueva fechaInicial y con el porcentaje
		 * deseado.
		 */
		int id_consultor;
		int id_concepto;
    	EntityManager em = null;
    	
		try {
			em = factory.createEntityManager();

			Dedicacion dedicacion = em.find(Dedicacion.class, id_dedicacion);
			id_consultor = dedicacion.getConsultor().getId_consultor();
			id_concepto = dedicacion.getConcepto().getId_concepto();
			
		} catch (EntityNotFoundException exc) {
			throw new PersistenceException("No se ha encontrado la dedicación especificada.");
		} finally {
			if (em != null) {
				em.close();
			}
		}
		//TODO añadir fechaFin
		//crearDedicacion(id_consultor, id_concepto, fechaInicial, nuevoPorcentajeDedicacion);
	}
    
	/** 
	 * Permite especificar la fecha final de la dedicación con el porcentaje que consta 
	 * en el momento de la modificación.
         * 
         * @param id_dedicacion
         * @param fechaFinalizacion
         */
    public void finalizarDedicacion(int id_dedicacion, Date fechaFinalizacion) {

    	EntityManager em = null;
		try {
			em = factory.createEntityManager();
			EntityTransaction tx = em.getTransaction();
			tx.begin();

			Dedicacion dedicacion = em.find(Dedicacion.class, id_dedicacion);
			dedicacion.setFechaFin(fechaFinalizacion);
		
			tx.commit();
			
		} catch (EntityNotFoundException exc) {
			throw new PersistenceException("No se ha encontrado la dedicación especificada.");
		} finally {
			if (em != null) {
				em.close();
			}
		}
	}

	
	/**
	 * Devuelve lista de dedicaciones activas durante el período seleccionado, de ToDo PROYECTO O BAJA del consultor seleccionado.
	 * La fechas son inclusivas. 
         *  
	 * @param id_consultor
	 * @param dateIni
	 * @param numDias TODO refactorizar los métodos de forma que reciban fechaFin en lugar de numDias.
	 * @return
	 */
	@SuppressWarnings("unchecked")
    @Override
	public List<Dedicacion> obtenerDedicacionesByConsultorByPeriod(int id_consultor, Date fechaInicio,
			int numDias) {
		EntityManager em = null;
//		List<Dedicacion> dedicacionesRaw = new ArrayList<Dedicacion>();
		List<Dedicacion> dedicaciones = new ArrayList<Dedicacion>();
				
		if (fechaInicio == null) {
			fechaInicio = new Date();
		}
		fechaInicio = Utilities.FechaACero(fechaInicio);
		// +1 para que sea inclusivo
		Date fechaFin = Utilities.calcularSumaDias(fechaInicio, numDias+1);
		
		try {
			em = factory.createEntityManager();		
		
			Consultor consultor = em.getReference(Consultor.class, id_consultor);
			
			org.hibernate.Session session = 
				(org.hibernate.Session) em.getDelegate();
			//Ya haya empezado:
			Criterion fechaInicioRestriction = Restrictions.le("fechaInicio", fechaFin); 
			//No haya finalizado:
			Criterion fechaFinRestriction = Restrictions.or(Restrictions.ge("fechaFin", fechaInicio), Restrictions.isNull("fechaFin"));
		// Obtenemos dedicaciones iniciadas antes de la fecha final:
			dedicaciones =
					session.createCriteria(Dedicacion.class)
					.add(Restrictions.eq("consultor", consultor))
					.add(fechaInicioRestriction)
					.add(fechaFinRestriction)
					.list();
/*			// Filtramos las dedicaciones ya finalizadas:
			for (Dedicacion dedicacion : dedicacionesRaw) {
				if (dedicacion.getFechaFin() == null || dedicacion.getFechaFin().after(dateIni) ) {
					dedicaciones.add(dedicacion);
				}
			}*/
			
		} finally {
			if (em != null) {
				em.close();
			}
		}
		
		return dedicaciones;
		
	}
	
	/**
	 * Devuelve lista de dedicaciones activas durante el período seleccionado para el consultor y concepto seleccionados.
	 * La fechas son inclusivas.
	 * 
	 * @param id_consultor
	 * @param dateIni
	 * @param numDias TODO refactorizar los métodos de forma que reciban fechaFin en lugar de numDias.
	 * @return
	 */
	@SuppressWarnings("unchecked")
    @Override
	public List<Dedicacion> obtenerDedicacionesByConsultorByConceptoByPeriod (
			int id_consultor, int id_concepto, Date fechaInicio, int numDias) {
		EntityManager em = null;
//		List<Dedicacion> dedicacionesRaw = new ArrayList<Dedicacion>();
		List<Dedicacion> dedicaciones = new ArrayList<Dedicacion>();
		
		if (fechaInicio == null) {
			fechaInicio = new Date();
		}
		fechaInicio = Utilities.FechaACero(fechaInicio);
		// +1 para que sea inclusivo
		Date fechaFin = Utilities.calcularSumaDias(fechaInicio, numDias+1);
		
		try {
			em = factory.createEntityManager();		
		
			Consultor consultor = em.getReference(Consultor.class, id_consultor);
			Concepto concepto = em.getReference(Concepto.class, id_concepto);
			
			org.hibernate.Session session = 
				(org.hibernate.Session) em.getDelegate();
			//Ya haya empezado:
			Criterion fechaInicioRestriction = Restrictions.le("fechaInicio", fechaFin); 
			//No haya finalizado:
			Criterion fechaFinRestriction = Restrictions.or(Restrictions.ge("fechaFin", fechaInicio), Restrictions.isNull("fechaFin"));
		// Obtenemos dedicaciones iniciadas antes de la fecha final:
			dedicaciones =
					session.createCriteria(Dedicacion.class)
					.add(Restrictions.eq("consultor", consultor))
					.add(Restrictions.eq("concepto", concepto))
					.add(fechaInicioRestriction)
					.add(fechaFinRestriction)
					.list();
/*			// Filtramos las dedicaciones ya finalizadas:
			for (Dedicacion dedicacion : dedicacionesRaw) {
				if (dedicacion.getFechaFin() == null || dedicacion.getFechaFin().after(dateIni) ) {
					dedicaciones.add(dedicacion);
				}
			}
*/			
		} catch (NoResultException exc) {
			return null;
		} finally {
			if (em != null) {
				em.close();
			}
		}
		
		return dedicaciones;
		
	}
	
	/**
	 * Suma las dedicaciones de un cierto consultor para cada día y las retorna
	 * ordenadas por fecha en forma de mapa.
	 * 
	 * Aunque normalmente le llegará una lista de dedicaciones ya filtrada para 
	 * cierto período, el método filtra por si fuese usado con una lista
	 * no filtrada o se quisiera filtrar un subconjunto del filtrado anterior.
	 * 
	 */
	// TODO refactorizar los métodos de forma que reciban fechaFin en lugar de numDias.
    @Override
	public Map<String, Integer> mapearPeriodoByConsultor(
			List<Dedicacion> dedicaciones, Date fechaInicio, int numDias) {
		
		/* Si numDias == 0, mostramos por defecto 31*/
		if (numDias == 0) {
			numDias = 31;
		}
		
		Date fechaActual;
		Map<String, Integer> mapDaysDedicacionesAcumuladas = new HashMap<String, Integer>();
		Map<String, Integer> mapOrdenado = null;
		
		/*Iteramos sobre cada día para ver el acumulado de las dedicaciones en ese consultor*/
		for (int i = 0; i < numDias; i++) {
			fechaActual = Utilities.calcularSumaDias(fechaInicio, i);
			
			int sumaPorcentaje = 0;
			for (Dedicacion dedicacion : dedicaciones) {
				if (dedicacion.getFechaInicio().before(fechaActual) || dedicacion.getFechaInicio().equals(fechaActual)) {
					if ( (dedicacion.getFechaFin() == null) || 
							(dedicacion.getFechaFin() !=  null && dedicacion.getFechaFin().after(fechaActual)) ) {
						sumaPorcentaje += dedicacion.getPorcentajeDedicacionDiaria();
					}

				}
			}
			
			/*Insertamos la fechaActual con el formato yyyy/MM/dd para poder ordenar con un TreeMap por defecto*/
			SimpleDateFormat fmt = new SimpleDateFormat("yyyy/MM/dd");
			//Si dedicaciones==null o ninguna en ese período, suma = 0.
			mapDaysDedicacionesAcumuladas.put(fmt.format(fechaActual), sumaPorcentaje); 
			mapOrdenado = new TreeMap<String, Integer>(mapDaysDedicacionesAcumuladas);
			
		}
		return mapOrdenado;
	}

	/**
	 * Suma las dedicaciones de un cierto consultor para cada día y las retorna ordenadas por fecha en forma de mapa.
         * 
         * @param dedicaciones
         * @param fechaInicio
         * @param numDias  TODO refactorizar los métodos de forma que reciban fechaFin en lugar de numDias.
         * @return 
         */
    @Override
	public Map<String, Integer> mapearPeriodoByConsultorByConcepto(
			List<Dedicacion> dedicaciones, Date fechaInicio, int numDias) {
		
		/* Si numDias == 0, mostramos por defecto 31*/
		if (numDias == 0) {
			numDias = 31;
		}
		
		Date fechaActual;
		Map<String, Integer> mapDaysDedicacionesAcumuladas = new HashMap<String, Integer>();
		Map<String, Integer> mapOrdenado = null;
		SimpleDateFormat fmt = new SimpleDateFormat("yyyy/MM/dd");
		
		/*Iteramos sobre cada día*/
		for (int i = 0; i < numDias; i++) {
			fechaActual = Utilities.calcularSumaDias(fechaInicio, i);
			if (dedicaciones != null) { 
				for (Dedicacion dedicacion : dedicaciones) {
					if (dedicacion.getFechaInicio().before(fechaActual)
							|| dedicacion.getFechaInicio().equals(fechaActual)) {
						if ((dedicacion.getFechaFin() == null)
								|| (dedicacion.getFechaFin() != null && dedicacion
										.getFechaFin().after(fechaActual))) {
							mapDaysDedicacionesAcumuladas.put(
									fmt.format(fechaActual),
									dedicacion.getPorcentajeDedicacionDiaria());
						}

					} else {
						mapDaysDedicacionesAcumuladas.put(fmt.format(fechaActual), 0);
					}
				}
			} else { //dedicaciones == null
				mapDaysDedicacionesAcumuladas.put(fmt.format(fechaActual), 0);
			}
			// Aprovechamos el orden natural de las strings (yyyy/MM/dd)
			mapOrdenado = new TreeMap<String,Integer>(mapDaysDedicacionesAcumuladas);		
		}
		return mapOrdenado;
	}


    @Override
	public void eliminarDedicacion(int id_dedicacion) {
		// TODO Auto-generated method stub
		
	}

}
